/*This file is part of Sandbox.

Sandbox is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License.

Sandbox is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Sandbox.  If not, see <http://www.gnu.org/licenses/>.

For contact, see the About page of my blog: <http://mygeekyware.wordpress.com/>.*/

#include <iostream>
#include "controlador.h"
#include "definiciones.h"
#include <SDL/SDL.h>
#include <SDL/SDL_events.h>
#include "particula.h"
#include <math.h>

using namespace std;

void controlador::UpdateMatrix(particula matriz[400][220]) {
    int i,j; //Acumulators to go trhough the matrix
    particlescount = 0;
    int random = rand() % 3 + 1;
    contadorgeneral+=random;
    if (contadorgeneral>10000)
        contadorgeneral = 0;
    for (i=0;i<400;i++) {
        for (j=0;j<220;j++) {
            if (contadorgeneral%3 == 0 && matriz[i][j].update_temp == true && i > 0 && i < 399 && j > 0 && j < 219)
                UpdateTemperature(matriz,i,j);
            else if (matriz[i][j].update_temp == false) {
                matriz[i][j].update_temp = true;
            }
            if (matriz[i][j].tipo == 0)
                Clear(matriz,i,j);
            else if (matriz[i][j].tipo != 0 && matriz[i][j].tipo != 1) {
                particlescount++;
                if (matriz[i][j].update == true) {
                    switch(matriz[i][j].tipo) {
                        case WATER:
                            Water(matriz, i, j);
                            break;
                        case SAND:
                            Sand(matriz, i, j);
                            break;
                        case SALT:
                            Salt(matriz, i, j);
                            break;
                        case SALTWATER:
                            SaltWater(matriz, i, j);
                            break;
                        case STONE:
                            Stone(matriz, i, j);
                            break;
                        case FIRE:
                            Fire(matriz, i, j);
                            break;
                        case EARTH:
                            Earth(matriz, i, j);
                            break;
                        case PLANT:
                            Plant(matriz, i, j);
                            break;
                        case STEAM:
                            Steam(matriz, i, j);
                            break;
                        case ICE:
                            Ice(matriz,i,j);
                            break;
                        case MAGMA:
                            Magma(matriz,i,j);
                            break;
                        case FIREWORK:
                            Firework(matriz,i,j);
                            break;
                        case TORCH:
                            Torch(matriz,i,j);
                            break;
                        case BOMB:
                            Bomb(matriz,i,j);
                            break;
                        case FUSE:
                            Fuse(matriz,i,j);
                            break;
                        case OIL:
                            Oil(matriz,i,j);
                            break;
                    }
                }
                else if (matriz[i][j].update == false) {
                    matriz[i][j].update = true;
                    continue;
                }
                if (i + matriz[i][j].vx < 0 || i + matriz[i][j].vx >= 400 ||
                        j + matriz[i][j].vy < 0 || j + matriz[i][j].vy >= 220) {
                    Clear(matriz, i, j);
                    continue;
                }
            }
            
        }
    }
}

void controlador::Copy(particula matriz[400][220], int x, int y, int dx, int dy) {
    matriz[dx][dy].peso = matriz[x][y].peso;
    matriz[dx][dy].tipo = matriz[x][y].tipo;
    matriz[dx][dy].tipo2 = matriz[x][y].tipo2;
    matriz[dx][dy].vx = matriz[x][y].vx;
    matriz[dx][dy].vy = matriz[x][y].vy;
    matriz[dx][dy].contador = matriz[x][y].contador;
}

void controlador::Clear(particula matriz[400][220], int x, int y) {
    matriz[x][y].contador = 0;
    matriz[x][y].tipo = 0;
    matriz[x][y].tipo2 = 0;
    matriz[x][y].empuje = 0;
    matriz[x][y].peso = 0;
    matriz[x][y].update = true;
    matriz[x][y].vx = 0;
    matriz[x][y].vy = 0;
}

void controlador::Swap(particula matriz[400][220], int x, int y, int dx, int dy) {
    int tipo = matriz[x][y].tipo;
    int peso = matriz[x][y].peso;
    int tipo2 = matriz[x][y].tipo2;
    matriz[x][y].tipo = matriz[dx][dy].tipo;
    matriz[x][y].tipo2 = matriz[dx][dy].tipo2;
    matriz[x][y].peso = matriz[dx][dy].peso;
    matriz[dx][dy].tipo = tipo;
    matriz[dx][dy].tipo2 = tipo2;
    matriz[dx][dy].peso = peso;
}

void controlador::UpdateTemperature(particula matriz[400][220], int x, int y) {
    if (matriz[x][y].temperatura == 0)
        return;
    int i,j;
    for (i = -1; i < 2;i++) {
        for (j=-1;j<2;j++) {
            if ( i == 0 && j == 0)
                continue;
            if (i != 0 && j != 0)
                continue;
            if (matriz[x+i][y+j].temperatura == 0) {
                if (matriz[x][y].temperatura > 0)
                    matriz[x+i][y+j].temperatura = matriz[x][y].temperatura-1;
                else if (matriz[x][y].temperatura < 0)
                    matriz[x+i][y+j].temperatura = matriz[x][y].temperatura+1;
                if (i == 1 || (j == 1 && i >= 0))
                    matriz[x+i][y+j].update_temp = false;
            }
        }
    }
    if (matriz[x][y].temperatura > 0 && contadorgeneral%2 == 0)
        matriz[x][y].temperatura--;
    else if (contadorgeneral%2 == 0)
        matriz[x][y].temperatura++;
}

bool controlador::chkReaction(int el1, int el2) {
    switch (el1) {
        case 0:
            return false;
            break;
        case 1:
            return false;
            break;
        case WATER:
            if (el2 == SALT || el2 == EARTH || el2 == ICE || el2 == MAGMA)
                return true;
            else
                return false;
            break;
        case 3:
            return false;
            break;
        case 4:
            return false;
        case FIRE:
            if (el2 == PLANT)
                return true;
            else
                return false;
    }
}